package com.wang.tool.invoker;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

class Demo {


    public static void main(String[] args) {
//        通用执行器，解决一些场景运行逻辑的包装


//        一.并行场景执行器ConcurrentInvoker
//        设计思路是使用线程池批量运行任务，并给出回调的方式处理异常
        ArrayList<Runnable> objects = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            objects.add(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
//                    干活
                    System.out.println();
                }
            });
        }

//        这里线程池建议使用ExecutorFactory构建，管理线程切换上下文
        ExecutorService service = Executors.newFixedThreadPool(3);
//        1.并行调用一批任务，等待结束
        ConcurrentInvoker.batchRun("可监控的动作码", service, 200, objects, new BiConsumer<Integer, Throwable>() {
            @Override
            public void accept(Integer integer, Throwable throwable) {
//                粗线异常时调用
//                如果此函数抛出，则异常会抛出到主线程
//
            }
        });

        ArrayList<Callable<String>> calls = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            calls.add(new Callable() {
                @Override
                public String call() throws Exception {
                    return null;
                }
            });
        }

        List<String> params = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            params.add(i + "");
        }

//        一批参数使用一个任务批量处理
        ConcurrentInvoker.batchProcess("可监控动作码", service, 200, params, new Consumer<String>() {
            @Override
            public void accept(String s) {

//                处理任务
            }
        }, new BiConsumer<Integer, Throwable>() {
            @Override
            public void accept(Integer integer, Throwable throwable) {
//                处理异常
            }
        });


//        2.并行执行任务，谁最快返回，要谁的结果
        ConcurrentInvoker.takeFaster("可监控动作码", service, 200, calls);




//        3.并行执行任务，根据优先级选取结果，calls中排在前面的失败了，才会选用后面的结果
        ConcurrentInvoker.takeHigherPriority("可监控动作码", service, 200, calls);



//        二.循环执行器

//        根据分页配置循环执行任务
        CycleInvoker.pageProcess(params, 10, new Consumer<List<String>>() {
            @Override
            public void accept(List<String> objects) {
//                这里是一页的10个参数
            }
        });





    }

}